import { ICommonObj, ITreeItem } from '@/types'

/**
 * 数组对象转为树结构
 * @param list 数组
 * @param parentId 父id
 */
export const list2Tree = (list: ITreeItem[], parentId: number) => {
  // 缓存数据
  const itemObj: ICommonObj = {}
  list.forEach((item) => {
    item.children = []
    itemObj[item.id] = item
  })
  return list.filter((item) => {
    // 对比父id是否相同
    if (item.pid !== parentId) {
      itemObj[item.pid].children.push(item)
      return false
    }
    return true
  })
}

/**
 * 将树形结构平铺成数组
 * @param nodes 树形数据
 */
export const flattenTree = (nodes: ITreeItem[]): ITreeItem[] => {
  const result: ITreeItem[] = []

  // 递归函数用于遍历树结构
  const flatten = (node: ITreeItem) => {
    const { children, ...rest } = node // 将 children 属性排除掉
    result.push(rest) // 将当前节点添加到结果数组

    // 如果当前节点有 children，递归遍历 children
    if (node.children) {
      node.children.forEach((child: ITreeItem) => flatten(child))
    }
  }

  // 遍历所有的根节点
  nodes.forEach((rootNode) => flatten(rootNode))

  return result
}

/**
 * 深拷贝对象
 * @param obj 对象
 */
export const deepCopyObject = (obj: Object) => {
  return JSON.parse(JSON.stringify(obj))
}

/**
 * 从数组对象中根据key值查找对象
 * @param array 数组对象
 * @param key 查找的键名
 * @param value 匹配的值
 */
export const findItemByKey = (array: any[], key: string, value: any) => {
  return array.find((item) => item[key] === value)
}

/**
 * 数组去重
 * @param array 数组
 */
export const uniqueArray = (array: any[]): any[] => {
  return Array.from(new Set(array))
}

/**
 * 截取字符串
 * @param str 字符串
 * @param limit 字数限制
 */
export const limitString = (str: string, limit: number): string => {
  if (str) {
    return str.length > limit ? `${str.substring(0, limit)}...` : str
  }

  return ''
}
